package com.qf.index;

import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class Test5 {
    public static void main(String[] args) {
        // 初始化三层 Map（aid, Type, Id -> Url）
        Map<Integer, Map<Integer, Map<Integer, String>>> aidTypeIdUrlMap = new ConcurrentHashMap<>();

        // 初始化二层 Map（Type, Id -> Url）
        Map<Integer, Map<Integer, String>> typeIdUrlMap = new ConcurrentHashMap<>();

        // 模拟数据：向 typeIdUrlMap 中添加数据
        typeIdUrlMap.computeIfAbsent(1, k -> new ConcurrentHashMap<>()).put(101, "http://example.com/1-101");
        typeIdUrlMap.computeIfAbsent(1, k -> new ConcurrentHashMap<>()).put(102, "http://example.com/1-102");
        typeIdUrlMap.computeIfAbsent(2, k -> new ConcurrentHashMap<>()).put(201, "http://example.com/2-201");

        // 模拟数据：向 aidTypeIdUrlMap 中添加空结构
        putAidTypeIdUrlMap(aidTypeIdUrlMap, 10, 1, 101, "");
        putAidTypeIdUrlMap(aidTypeIdUrlMap, 10, 3, 201, "");
        putAidTypeIdUrlMap(aidTypeIdUrlMap, 20, 1, 102, "");

        // 将 typeIdUrlMap 中的数据填充到 aidTypeIdUrlMap 中
        Map<Integer, Map<Integer, Map<Integer, String>>> integerMapMap = mergeUrls(aidTypeIdUrlMap, typeIdUrlMap);

        // 打印结果
        integerMapMap.forEach((aid, typeMap) -> {
            System.out.println("Aid: " + aid);
            typeMap.forEach((type, idMap) -> {
                System.out.println("  Type: " + type);
                idMap.forEach((id, url) -> {
                    System.out.println("    Id: " + id + ", Url: " + url);
                });
            });
        });
    }

    public static void putAidTypeIdUrlMap(Map<Integer, Map<Integer, Map<Integer, String>>> aidTypeIdUrlMap, int aid, int type, int id, String url) {
        aidTypeIdUrlMap.computeIfAbsent(aid, k -> new ConcurrentHashMap<>()).computeIfAbsent(type, k -> new ConcurrentHashMap<>()).put(id, url);
    }

    /**
     * 将 typeIdUrlMap 中的 Url 数据填充到 aidTypeIdUrlMap 中。
     *
     * @param aidTypeIdUrlMap 三层 Map（aid, Type, Id -> Url）
     * @param typeIdUrlMap    二层 Map（Type, Id -> Url）
     */
    public static void mergeMaps(Map<Integer, Map<Integer, Map<Integer, String>>> aidTypeIdUrlMap, Map<Integer, Map<Integer, String>> typeIdUrlMap) {
        // 遍历 typeIdUrlMap
        typeIdUrlMap.forEach((type, idUrlMap) -> {
            idUrlMap.forEach((id, url) -> {
                // 遍历 aidTypeIdUrlMap，找到匹配的 Type 和 Id，并填充 Url
                aidTypeIdUrlMap.forEach((aid, typeMap) -> {
                    typeMap.computeIfAbsent(type, k -> new ConcurrentHashMap<>()).put(id, url);
                });
            });
        });
    }
    public static Map<Integer, Map<Integer, Map<Integer, String>>> mergeUrls(Map<Integer, Map<Integer, Map<Integer, String>>> aidTypeIdUrlMap, Map<Integer, Map<Integer, String>> typeIdUrlMap) {
        Map<Integer, Map<Integer, Map<Integer, String>>> resultMap = new ConcurrentHashMap<>();
        Set<Map.Entry<Integer, Map<Integer, Map<Integer, String>>>> entries = aidTypeIdUrlMap.entrySet();
        aidTypeIdUrlMap.entrySet().parallelStream().forEach(entry -> {




        });


        aidTypeIdUrlMap.keySet().parallelStream().forEach(aid -> {
            Map<Integer, Map<Integer, String>> aTypeIdUrlMap = aidTypeIdUrlMap.get(aid);
            for (Map.Entry<Integer, Map<Integer, String>> entry : aTypeIdUrlMap.entrySet()) {
                Integer type = entry.getKey();
                Map<Integer, String> aIdUrlMap = entry.getValue();
                for (Map.Entry<Integer, String> map : aIdUrlMap.entrySet()) {
                    Integer id = map.getKey();
                    if (typeIdUrlMap.containsKey(type) && typeIdUrlMap.get(type).containsKey(id)) {
                        String url = typeIdUrlMap.get(type).get(id);
                        resultMap.computeIfAbsent(aid, k -> new ConcurrentHashMap<>()).computeIfAbsent(type, k -> new ConcurrentHashMap<>()).put(id, url);
                        break;
                    }
                }
            }
        });
        return resultMap;
    }

//    public static Map<Integer, Map<Integer, Map<Integer, String>>> mergeUrls(Map<Integer, Map<Integer, Map<Integer, String>>> aidTypeIdUrlMap, Map<Integer, Map<Integer, String>> typeIdUrlMap) {
//        Map<Integer, Map<Integer, Map<Integer, String>>> resultMap = new ConcurrentHashMap<>();
//        aidTypeIdUrlMap.keySet().parallelStream().forEach(aid -> {
//            Map<Integer, Map<Integer, String>> aTypeIdUrlMap = aidTypeIdUrlMap.get(aid);
//            for (Map.Entry<Integer, Map<Integer, String>> entry : aTypeIdUrlMap.entrySet()) {
//                Integer type = entry.getKey();
//                Map<Integer, String> aIdUrlMap = entry.getValue();
//                for (Map.Entry<Integer, String> map : aIdUrlMap.entrySet()) {
//                    Integer id = map.getKey();
//                    if (typeIdUrlMap.containsKey(type) && typeIdUrlMap.get(type).containsKey(id)) {
//                        String url = typeIdUrlMap.get(type).get(id);
//                        resultMap.computeIfAbsent(aid, k -> new ConcurrentHashMap<>()).computeIfAbsent(type, k -> new ConcurrentHashMap<>()).put(id, url);
//                        break;
//                    }
//                }
//            }
//        });
//        return resultMap;
//    }


}
